/**
 * 用户管理工具函数
 */

/**
 * 格式化用户ID显示
 * @param {string} id - 用户ID
 * @returns {string} 格式化后的ID
 */
export const formatUserId = (id) => {
  if (!id) return ''
  return id.substring(0, 8) + '...'
}

/**
 * 格式化日期时间
 * @param {string} dateTimeStr - 日期时间字符串
 * @returns {string} 格式化后的日期时间
 */
export const formatDateTime = (dateTimeStr) => {
  if (!dateTimeStr) return ''
  const date = new Date(dateTimeStr)
  return date.toLocaleString('zh-CN', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit'
  })
}

/**
 * 格式化日期
 * @param {string} dateStr - 日期字符串
 * @returns {string} 格式化后的日期
 */
export const formatDate = (dateStr) => {
  if (!dateStr) return ''
  const date = new Date(dateStr)
  return date.toLocaleDateString('zh-CN')
}

/**
 * 手机号脱敏
 * @param {string} phone - 手机号
 * @returns {string} 脱敏后的手机号
 */
export const maskPhone = (phone) => {
  if (!phone) return ''
  return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
}

/**
 * 邮箱脱敏
 * @param {string} email - 邮箱
 * @returns {string} 脱敏后的邮箱
 */
export const maskEmail = (email) => {
  if (!email) return ''
  const [username, domain] = email.split('@')
  if (username.length <= 2) return email
  return username.substring(0, 2) + '***@' + domain
}

/**
 * 获取状态名称
 * @param {number} status - 状态值
 * @returns {string} 状态名称
 */
export const getStatusName = (status) => {
  const statusMap = {
    1: '启用',
    0: '禁用'
  }
  return statusMap[status] || '未知'
}

/**
 * 获取状态类型（用于标签颜色）
 * @param {number} status - 状态值
 * @returns {string} 状态类型
 */
export const getStatusType = (status) => {
  const typeMap = {
    1: 'success',
    0: 'danger'
  }
  return typeMap[status] || ''
}

/**
 * 获取角色类型（用于标签颜色）
 * @param {string} roleName - 角色名称
 * @returns {string} 角色类型
 */
export const getRoleType = (roleName) => {
  const typeMap = {
    '超级管理员': 'danger',
    '管理员': 'warning',
    '编辑': 'info',
    '普通用户': ''
  }
  return typeMap[roleName] || ''
}

/**
 * 验证手机号格式
 * @param {string} phone - 手机号
 * @returns {boolean} 是否有效
 */
export const validatePhone = (phone) => {
  const phoneRegex = /^1[3-9]\d{9}$/
  return phoneRegex.test(phone)
}

/**
 * 验证邮箱格式
 * @param {string} email - 邮箱
 * @returns {boolean} 是否有效
 */
export const validateEmail = (email) => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
  return emailRegex.test(email)
}

/**
 * 验证用户名格式
 * @param {string} username - 用户名
 * @returns {boolean} 是否有效
 */
export const validateUsername = (username) => {
  const usernameRegex = /^[a-zA-Z0-9_]{3,20}$/
  return usernameRegex.test(username)
}

/**
 * 验证密码强度
 * @param {string} password - 密码
 * @returns {object} 密码强度信息
 */
export const validatePassword = (password) => {
  const result = {
    isValid: false,
    strength: 0,
    message: ''
  }
  
  if (!password) {
    result.message = '密码不能为空'
    return result
  }
  
  if (password.length < 6) {
    result.message = '密码长度至少6位'
    return result
  }
  
  if (password.length > 20) {
    result.message = '密码长度不能超过20位'
    return result
  }
  
  let strength = 0
  
  // 包含数字
  if (/\d/.test(password)) strength++
  
  // 包含小写字母
  if (/[a-z]/.test(password)) strength++
  
  // 包含大写字母
  if (/[A-Z]/.test(password)) strength++
  
  // 包含特殊字符
  if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) strength++
  
  result.strength = strength
  result.isValid = true
  
  if (strength >= 4) {
    result.message = '密码强度：强'
  } else if (strength >= 2) {
    result.message = '密码强度：中'
  } else {
    result.message = '密码强度：弱'
  }
  
  return result
}

/**
 * 获取用户头像显示文本
 * @param {object} user - 用户对象
 * @returns {string} 头像显示文本
 */
export const getUserAvatarText = (user) => {
  if (!user) return ''
  
  // 优先使用用户名
  if (user.userName) {
    return user.userName.charAt(0).toUpperCase()
  }
  
  // 使用邮箱
  if (user.email) {
    return user.email.charAt(0).toUpperCase()
  }
  
  return 'U'
}

/**
 * 获取用户显示名称
 * @param {object} user - 用户对象
 * @returns {string} 显示名称
 */
export const getUserDisplayName = (user) => {
  if (!user) return ''
  
  if (user.userName) {
    return user.userName
  }
  
  if (user.email) {
    return user.email.split('@')[0]
  }
  
  return '未知用户'
}

/**
 * 获取用户角色显示文本
 * @param {array} roles - 角色数组
 * @returns {string} 角色显示文本
 */
export const getUserRolesText = (roles) => {
  if (!roles || roles.length === 0) {
    return '无角色'
  }
  
  return roles.map(role => role.roleName).join(', ')
}

/**
 * 检查用户是否有指定角色
 * @param {object} user - 用户对象
 * @param {string} roleName - 角色名称
 * @returns {boolean} 是否有该角色
 */
export const hasRole = (user, roleName) => {
  if (!user || !user.roles) return false
  return user.roles.some(role => role.roleName === roleName)
}

/**
 * 检查用户是否启用
 * @param {object} user - 用户对象
 * @returns {boolean} 是否启用
 */
export const isUserEnabled = (user) => {
  return user && user.accountStatus === 1
}

/**
 * 获取用户状态图标
 * @param {object} user - 用户对象
 * @returns {string} 图标名称
 */
export const getUserStatusIcon = (user) => {
  if (!user) return 'User'
  
  if (user.accountStatus === 1) {
    return 'User'
  } else {
    return 'Lock'
  }
}

/**
 * 格式化文件大小
 * @param {number} bytes - 字节数
 * @returns {string} 格式化后的文件大小
 */
export const formatFileSize = (bytes) => {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 防抖函数
 * @param {function} func - 要防抖的函数
 * @param {number} wait - 等待时间
 * @returns {function} 防抖后的函数
 */
export const debounce = (func, wait) => {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {function} func - 要节流的函数
 * @param {number} limit - 限制时间
 * @returns {function} 节流后的函数
 */
export const throttle = (func, limit) => {
  let inThrottle
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}

